package com.malou.client.ventas.modeloprenda;


import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.LoadEvent;
import com.extjs.gxt.ui.client.data.Loader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.malou.client.MalouConstants;
import com.malou.client.MalouMessages;
import com.malou.client.graficosestadisticos.GPrendaVendidaxFechaPanel;
import com.malou.client.graficosestadisticos.PrendaVendidaxFechaPanel;
import com.malou.client.util.MensajeData;
import com.malou.client.util.Utilities;
import com.malou.client.ventas.cambio.Cambio;
import com.malou.client.ventas.cambio.CambioDialog;
import com.malou.client.ventas.cambio.DevolucionPrendaDialog;
import com.malou.client.ventas.ingresostock.IngresoStock;
import com.malou.client.ventas.movimiento.entrada.MovimientoEntradaDialog;
import com.malou.client.ventas.movimiento.salida.MovimientoSalidaDialog;
import com.malou.client.ventas.salidastock.SalidaStock;
import com.malou.client.ventas.separacion.SeparacionDialog;
import com.malou.client.ventas.tipoprendas.TipoPrenda;
import com.malou.client.ventas.variacion.Variacion;
import com.malou.client.ventas.venta.VentaDialog;

public class ModeloPrendas {
	private static ModeloPrendaServiceAsync mps = GWT.create(ModeloPrendaService.class);
	private static MalouConstants constants = GWT.create(MalouConstants.class);
	private static MalouMessages messages = GWT.create(MalouMessages.class);

	public static PagingLoader<PagingLoadResult<ModelData>> loaderAutocomplete;
	public static ListStore<BeanModel> storeAutocomplete;
	public static PagingLoader<PagingLoadResult<ModelData>> loaderPrenda;
	public static ListStore<BeanModel> storePrenda;
	public static ModeloPrendaDialog modeloPrendaDialog;
	
	public static PagingLoader<PagingLoadResult<ModelData>> loaderAutocompletesalida;
	public static ListStore<BeanModel> storeAutocompletesalida;
	
	public static PagingLoader<PagingLoadResult<ModelData>> loaderAutocompleteingreso;
	public static ListStore<BeanModel> storeAutocompleteingreso;
	
	public static PagingLoader<PagingLoadResult<ModelData>> loaderAutocompletedevolucion;
	public static ListStore<BeanModel> storeAutocompletedevolucion;
	
	public static ListStore<BeanModel> storeTipoPrenda;
	public static ListLoader<ListLoadResult<ModelData>> loaderTipoPrenda;
	
	public static ListStore<BeanModel> storeVariacion;
	public static ListLoader<ListLoadResult<ModelData>> loaderVariacion;
	
	public static VentaDialog ventaDialog;
	public static SeparacionDialog separacionDialog;
	
	public static MovimientoEntradaDialog movimientoEntradaDialog;
	public static MovimientoSalidaDialog movimientoSalidaDialog;
	
	public static CambioDialog cambioDialog;
	public static DevolucionPrendaDialog devolucionprendaDialog;
	public static IngresoaOfertaDialog ingresoaofertaDialog;
	
	public static PrendaVendidaxFechaPanel prendaVendida;
	public static GPrendaVendidaxFechaPanel GprendaVendida;
	
	public static ListStore<BeanModel> storeModeloPrenda;
	public static ListLoader<ListLoadResult<ModelData>> loaderModeloPrenda;


	public static void getPaginate() {
		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {

			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((FilterPagingLoadConfig) loadConfig, callback);  
				
			}  
	      
	    };
	
	    loaderPrenda = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	    
	      };  
        loaderPrenda.setRemoteSort(true);

        storePrenda = new ListStore<BeanModel>(loaderPrenda);        
        
	}
	
	public static void save(ModeloPrenda mp) {
		
		
		mps.save(mp, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);	
				storePrenda.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					modeloPrendaDialog.hide();
					
						loaderPrenda.load(0, Utilities.itemsPerPage);
					
				}
				 else {
					 modeloPrendaDialog.status.hide();
					 storePrenda.rejectChanges();
					 String msg;
					 if(data.errorTipo == 1)
						 msg = constants.modeloPrendaNoTieneSerie();					 
					 else if(data.errorTipo == 2)
						 msg = constants.modeloPrendaYaExiste();
					 else if(data.errorTipo == 3)
						 msg = constants.modeloPrendaCodigoYaExiste();
					 else if(data.errorTipo == 4)
						 msg = messages.modeloPrendaCodigoLongitud(data.parametro);
					 else
						 msg = constants.modeloPrendaNoGuardado();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}						
			}
			
		});
	}
	
	public static void delete(Integer id) {
		  
		  mps.delete(id, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {					
						Integer offset =loaderPrenda.getOffset();
						loaderPrenda.load(offset, Utilities.itemsPerPage);						
					}
					 else {
									 
						 MessageBox.alert(constants.sistemaMarcocruzado(), constants.modeloPrendaNoEliminado(), null);
					}						
				}
				
			});
	  }
	
	public static void deleteAll(String ids) {
		  
		  mps.deleteAll(ids, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {					
						Integer offset =loaderPrenda.getOffset();
						loaderPrenda.load(offset, Utilities.itemsPerPage);						
					}
					 else {
								 
						 MessageBox.alert(constants.sistemaMarcocruzado(), constants.modeloPrendaNoEliminado(), null);
					}						
				}
				
			});
	  }
	
	public static void getComboTipoPrendas(){
		RpcProxy<List<TipoPrenda>> proxy = new RpcProxy<List<TipoPrenda>>() {

			@Override
			protected void load(Object loadConfig,AsyncCallback<List<TipoPrenda>> callback) {				
				mps.getTipoPrenda(callback);
			}		      
			
	    };
	    
	    loaderTipoPrenda= new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	    
	    storeTipoPrenda = new ListStore<BeanModel>(loaderTipoPrenda);
	}
	
	public static void getComboVariaciones(){
		RpcProxy<List<Variacion>> proxy = new RpcProxy<List<Variacion>>() {

			@Override
			protected void load(Object loadConfig,AsyncCallback<List<Variacion>> callback) {				
				mps.getVariaciones(callback);
			}		      
			
	    };
	    
	    loaderVariacion= new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	    
	    storeVariacion = new ListStore<BeanModel>(loaderVariacion);
	}
	
	
	
	
	
	public static void autoComplete() {		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((BasePagingLoadConfig) loadConfig, callback);  				
			}	      
	    };	
	    loaderAutocomplete = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader());	      
        loaderAutocomplete.setRemoteSort(true);        
        loaderAutocomplete.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {  
		      public void handleEvent(LoadEvent be) {  
		        be.<ModelData> getConfig().set("start", be.<ModelData> getConfig().get("offset"));  
		      }  
		    });      
        storeAutocomplete = new ListStore<BeanModel>(loaderAutocomplete);
	}
	
	

	public static void autoCompleteSalida() {		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((BasePagingLoadConfig) loadConfig, callback);  				
			}	      
	    };	
	    loaderAutocompletesalida = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader());	      
        loaderAutocompletesalida.setRemoteSort(true);        
        loaderAutocompletesalida.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {  
		      public void handleEvent(LoadEvent be) {  
		        be.<ModelData> getConfig().set("start", be.<ModelData> getConfig().get("offset"));  
		      }  
		    });      
        storeAutocompletesalida = new ListStore<BeanModel>(loaderAutocompletesalida);
	}

	public static void autoCompleteIngreso() {		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((BasePagingLoadConfig) loadConfig, callback);  				
			}	      
	    };	
	    loaderAutocompleteingreso = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader());	      
        loaderAutocompleteingreso.setRemoteSort(true);        
        loaderAutocompleteingreso.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {  
		      public void handleEvent(LoadEvent be) {  
		        be.<ModelData> getConfig().set("start", be.<ModelData> getConfig().get("offset"));  
		      }  
		    });      
        storeAutocompleteingreso = new ListStore<BeanModel>(loaderAutocompleteingreso);
	}
	
	public static void autoCompleteDevolucion() {		
		RpcProxy<PagingLoadResult<ModeloPrenda>> proxy = new RpcProxy<PagingLoadResult<ModeloPrenda>>() {
			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<ModeloPrenda>> callback) {
				mps.paginateModeloPrenda((BasePagingLoadConfig) loadConfig, callback);  				
			}	      
	    };	
	    loaderAutocompletedevolucion = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader());	      
        loaderAutocompletedevolucion.setRemoteSort(true);        
        loaderAutocompletedevolucion.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {  
		      public void handleEvent(LoadEvent be) {  
		        be.<ModelData> getConfig().set("start", be.<ModelData> getConfig().get("offset"));  
		      }  
		    });      
        storeAutocompletedevolucion = new ListStore<BeanModel>(loaderAutocompletedevolucion);
	}
	
	
	public static void getPrenda(String codigo) {		
		ventaDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					ventaDialog.prenda_id.setValue(result.getId().toString());
					ventaDialog.codigo.setValue(result.getCodigo());					
					ventaDialog.prenda.setRawValue(result.getNombre());					
					ventaDialog.preciounitario.setValue(result.getPrecioventa());
					ventaDialog.stock.setValue(result.getStock());
					ventaDialog.cantidad.setValue(1);
					
					ventaDialog.preciounitario.focus();
				}else{
					ventaDialog.prenda_id.setValue("");
					ventaDialog.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
	
	public static void getPrendaCambioIngreso(String codigoingreso){
		//cambioDialog.prendaingreso.setRawValue(constants.cargando());
		
		mps.getPrenda(codigoingreso , new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					cambioDialog.prendaingreso_id.setValue(result.getId().toString());
					cambioDialog.codigoingreso.setValue(result.getCodigo());
					cambioDialog.prendaingreso.setRawValue(result.getNombre());
					cambioDialog.cantidad_ingreso.setValue(result.getStock());
					cambioDialog.stockingreso.setValue(result.getStock());
					
				}else{
						cambioDialog.prendaingreso_id.setValue("");
						cambioDialog.prendaingreso.setRawValue("No Existe");
						cambioDialog.cantidad_ingreso.setValue(null);
						cambioDialog.stockingreso.setValue(null);
				}
			}
			
		});
		
	}
	
	public static void getPrendaSalidaaOferta(String codigoingreso){
		//cambioDialog.prendaingreso.setRawValue(constants.cargando());
		
		mps.getPrenda(codigoingreso , new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					ingresoaofertaDialog.prendasalida_id.setValue(result.getId().toString());
					ingresoaofertaDialog.codigosalida.setValue(result.getCodigo());
					ingresoaofertaDialog.prendasalida.setRawValue(result.getNombre());
					ingresoaofertaDialog.stocksalida.setValue(result.getStock());
					
				}else{
					ingresoaofertaDialog.prendasalida_id.setValue("");
					ingresoaofertaDialog.prendasalida.setRawValue("No Existe");
					ingresoaofertaDialog.cantidad_salida.setValue(null);
					ingresoaofertaDialog.stocksalida.setValue(null);
				}
			}
			
		});
		
	}
	
	public static void getPrendaIngresoaOferta(String codigoingreso){
		//cambioDialog.prendaingreso.setRawValue(constants.cargando());
		
		mps.getPrenda(codigoingreso , new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					ingresoaofertaDialog.prendaingreso_id.setValue(result.getId().toString());
					ingresoaofertaDialog.codigoingreso.setValue(result.getCodigo());
					ingresoaofertaDialog.prendaingreso.setRawValue(result.getNombre());
					ingresoaofertaDialog.cantidad_ingreso.setValue(1);
					ingresoaofertaDialog.stockingreso.setValue(result.getStock());
					
				}else{
					ingresoaofertaDialog.prendaingreso_id.setValue("");
					ingresoaofertaDialog.prendaingreso.setRawValue("No Existe");
					ingresoaofertaDialog.cantidad_ingreso.setValue(null);
					ingresoaofertaDialog.stockingreso.setValue(null);
				}
			}
			
		});
		
	}
		
	public static void getPrendaDevolucion(String codigodevolucion){
		        devolucionprendaDialog.prendadevolucion.setRawValue(constants.cargando());
		
				mps.getPrenda(codigodevolucion , new AsyncCallback<ModeloPrenda>() {

					@Override
					public void onFailure(Throwable caught) {
						MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
						
					}

					@Override
					public void onSuccess(ModeloPrenda result) {
						if(result != null){
							devolucionprendaDialog.prendadevolucion_id.setValue(result.getId().toString());
							devolucionprendaDialog.codigodevolucion.setValue(result.getCodigo());
							devolucionprendaDialog.prendadevolucion.setRawValue(result.getNombre());
							devolucionprendaDialog.cantidad_devolucion.setValue(1);
							//devolucionprendaDialog.montodevolucion.setValue(result.getPrecioventa());
							devolucionprendaDialog.montodev.setValue(result.getPrecioventa());
							devolucionprendaDialog.stockdevolucion.setValue(result.getStock());
							
						}else{
								devolucionprendaDialog.prendadevolucion_id.setValue("");
								devolucionprendaDialog.prendadevolucion.setRawValue("No Existe");
								devolucionprendaDialog.cantidad_devolucion.setValue(null);
								//devolucionprendaDialog.montodevolucion.setRawValue("");
								devolucionprendaDialog.stockdevolucion.setValue(null);
						}
					}
					
				});
		
	}
	
	
	public static void getPrendaCambioSalida(String codigosalida){
		cambioDialog.prendasalida.setRawValue(constants.cargando());
		
		mps.getPrenda(codigosalida , new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					cambioDialog.codigosalida.setValue(result.getCodigo());
					cambioDialog.prendasalida.setRawValue(result.getNombre().toString());
					cambioDialog.prendasalida_id.setValue(result.getId().toString());
					cambioDialog.cantidad_salida.setValue(1);
					cambioDialog.stocksalida.setValue(result.getStock());
					}else{
						cambioDialog.prendasalida_id.setValue("");
						cambioDialog.prendasalida.setRawValue("No Existe");
						cambioDialog.cantidad_salida.setValue(null);
						cambioDialog.stocksalida.setValue(null);
					}
				
			}
			
		});
		
	}
	
	public static void getPrendaSeparacion(String codigo) {		
		separacionDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					separacionDialog.prenda_id.setValue(result.getId().toString());
					separacionDialog.codigo.setValue(result.getCodigo());					
					separacionDialog.prenda.setRawValue(result.getNombre());					
					separacionDialog.preciounitario.setValue(result.getPrecioventa());
					separacionDialog.stock.setValue(result.getStock());
					
					separacionDialog.preciounitario.focus();
				}else{
					separacionDialog.prenda_id.setValue("");
					separacionDialog.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
	
	public static void getPrendaMovimientoEntrada(String codigo) {		
		movimientoEntradaDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					movimientoEntradaDialog.prenda_id.setValue(result.getId().toString());
					movimientoEntradaDialog.codigo.setValue(result.getCodigo());					
					movimientoEntradaDialog.prenda.setRawValue(result.getNombre());					
				}else{
					movimientoEntradaDialog.prenda_id.setValue("");
					movimientoEntradaDialog.prenda.setRawValue("No Existe");
				}									
			}
			
		});
	}
	
	public static void getPrendaMovimientoSalida(String codigo) {		
		movimientoSalidaDialog.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					movimientoSalidaDialog.prenda_id.setValue(result.getId().toString());
					movimientoSalidaDialog.codigo.setValue(result.getCodigo());					
					movimientoSalidaDialog.prenda.setRawValue(result.getNombre());	
					movimientoSalidaDialog.stock.setValue(result.getStock());	
				}else{
					movimientoSalidaDialog.prenda_id.setValue("");
					movimientoSalidaDialog.prenda.setRawValue("No Existe");
				}									
			}
			
		});
	}
	
	
	public static void getPrendaGrafico(String codigo) {		
		prendaVendida.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					prendaVendida.prenda_id = Integer.parseInt(result.getId().toString());					
					prendaVendida.codigo.setValue(result.getCodigo());					
					prendaVendida.prenda.setRawValue(result.getNombre());
					
					//ventaDialog.preciounitario.focus();
				}else{
					prendaVendida.prenda_id=null;
					prendaVendida.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
	
	public static void getGPrendaGrafico(String codigo) {		
		GprendaVendida.prenda.setRawValue(constants.cargando());
		
		mps.getPrenda(codigo, new AsyncCallback<ModeloPrenda>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
			}

			@Override
			public void onSuccess(ModeloPrenda result) {
				if(result != null){
					GprendaVendida.prenda_id = Integer.parseInt(result.getId().toString());					
					GprendaVendida.codigo.setValue(result.getCodigo());					
					GprendaVendida.prenda.setRawValue(result.getNombre());
					
				}else{
					GprendaVendida.prenda_id=null;
					GprendaVendida.prenda.setRawValue("No Existe");
				}
									
			}
			
		});
	}
	
	public static void getComboModeloPrendas(){
		RpcProxy<List<ModeloPrenda>> proxy = new RpcProxy<List<ModeloPrenda>>(){

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<List<ModeloPrenda>> callback) {
				mps.getModeloPrenda(callback);
				
			}
			
		};
		
        loaderModeloPrenda = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	    
	    storeModeloPrenda = new ListStore<BeanModel>(loaderModeloPrenda);
	
	}
	
	/*
	 * 	public static void save(Cambio cam,List<IngresoStock> lis){
		cs.save(cam, lis, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData result) {
				if (result.guardado) {
					devolucionprendaDialog.hide();
					loader.load(0, Utilities.itemsPerPage);
				}
				 else {
					 String msg = constants.stockPrendaNoGuardado();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}
				 devolucionprendaDialog.status.hide();
				 devolucionprendaDialog.getButtonBar().enable();
			 }
			
		});
	}

	 */
	
	public static void save(List<IngresoStock> ling,List<SalidaStock> lsal){
		mps.save(ling,lsal,new AsyncCallback<MensajeData>(){

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				storePrenda.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData result) {
				if(result.guardado){
				 ingresoaofertaDialog.hide();
				 loaderPrenda.load(0, Utilities.itemsPerPage);
		    	}else{
		    		String msg = constants.stockPrendaNoGuardado();
		    		MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
		    	}
				ingresoaofertaDialog.status.hide();
			    ingresoaofertaDialog.getButtonBar().enable();
			}
		});
	}
}
